/*
 * Copyright 2012 The Netty Project
 *
 * The Netty Project licenses this file to you under the Apache License,
 * version 2.0 (the "License"); you may not use this file except in compliance
 * with the License. You may obtain a copy of the License at:
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 * License for the specific language governing permissions and limitations
 * under the License.
 */
package io.netty.util;

import static io.netty.util.AsciiString.indexOf;

import io.netty.util.internal.PlatformDependent;
import io.netty.util.internal.SocketUtils;
import io.netty.util.internal.StringUtil;
import io.netty.util.internal.SystemPropertyUtil;
import io.netty.util.internal.logging.InternalLogger;
import io.netty.util.internal.logging.InternalLoggerFactory;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.Inet4Address;
import java.net.Inet6Address;
import java.net.InetAddress;
import java.net.InetSocketAddress;
import java.net.NetworkInterface;
import java.net.SocketException;
import java.net.UnknownHostException;
import java.security.AccessController;
import java.security.PrivilegedAction;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.List;

/**
 * A class that holds a number of network-related constants.
 * <p/>
 * This class borrowed some of its methods from a  modified fork of the <a
 * href="http://svn.apache.org/repos/asf/harmony/enhanced/java/branches/java6/classlib/modules/luni/
 * src/main/java/org/apache/harmony/luni/util/Inet6Util.java">Inet6Util class</a> which was part of
 * Apache Harmony.
 */
public final class NetUtil {

  /**
   * The {@link Inet4Address} that represents the IPv4 loopback address '127.0.0.1'
   */
  public static final Inet4Address LOCALHOST4;

  /**
   * The {@link Inet6Address} that represents the IPv6 loopback address '::1'
   */
  public static final Inet6Address LOCALHOST6;

  /**
   * The {@link InetAddress} that represents the loopback address. If IPv6 stack is available, it
   * will refer to {@link #LOCALHOST6}.  Otherwise, {@link #LOCALHOST4}.
   */
  public static final InetAddress LOCALHOST;

  /**
   * The loopback {@link NetworkInterface} of the current machine
   */
  public static final NetworkInterface LOOPBACK_IF;

  /**
   * The SOMAXCONN value of the current machine.  If failed to get the value,  {@code 200}  is used
   * as a default value for Windows or {@code 128} for others.
   */
  public static final int SOMAXCONN;

  /**
   * This defines how many words (represented as ints) are needed to represent an IPv6 address
   */
  private static final int IPV6_WORD_COUNT = 8;

  /**
   * The maximum number of characters for an IPV6 string with no scope
   */
  private static final int IPV6_MAX_CHAR_COUNT = 39;

  /**
   * Number of bytes needed to represent and IPV6 value
   */
  private static final int IPV6_BYTE_COUNT = 16;

  /**
   * Maximum amount of value adding characters in between IPV6 separators
   */
  private static final int IPV6_MAX_CHAR_BETWEEN_SEPARATOR = 4;

  /**
   * Minimum number of separators that must be present in an IPv6 string
   */
  private static final int IPV6_MIN_SEPARATORS = 2;

  /**
   * Maximum number of separators that must be present in an IPv6 string
   */
  private static final int IPV6_MAX_SEPARATORS = 8;

  /**
   * Maximum amount of value adding characters in between IPV4 separators
   */
  private static final int IPV4_MAX_CHAR_BETWEEN_SEPARATOR = 3;

  /**
   * Number of separators that must be present in an IPv4 string
   */
  private static final int IPV4_SEPARATORS = 3;

  /**
   * {@code true} if IPv4 should be used even if the system supports both IPv4 and IPv6.
   */
  private static final boolean IPV4_PREFERRED = SystemPropertyUtil
      .getBoolean("java.net.preferIPv4Stack", false);

  /**
   * {@code true} if an IPv6 address should be preferred when a host has both an IPv4 address and an
   * IPv6 address.
   */
  private static final boolean IPV6_ADDRESSES_PREFERRED =
      SystemPropertyUtil.getBoolean("java.net.preferIPv6Addresses", false);

  /**
   * The logger being used by this class
   */
  private static final InternalLogger logger = InternalLoggerFactory.getInstance(NetUtil.class);

  static {
    logger.debug("-Djava.net.preferIPv4Stack: {}", IPV4_PREFERRED);
    logger.debug("-Djava.net.preferIPv6Addresses: {}", IPV6_ADDRESSES_PREFERRED);

    byte[] LOCALHOST4_BYTES = {127, 0, 0, 1};
    byte[] LOCALHOST6_BYTES = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1};

    // Create IPv4 loopback address.
    Inet4Address localhost4 = null;
    try {
      localhost4 = (Inet4Address) InetAddress.getByAddress("localhost", LOCALHOST4_BYTES);
    } catch (Exception e) {
      // We should not get here as long as the length of the address is correct.
      PlatformDependent.throwException(e);
    }
    LOCALHOST4 = localhost4;

    // Create IPv6 loopback address.
    Inet6Address localhost6 = null;
    try {
      localhost6 = (Inet6Address) InetAddress.getByAddress("localhost", LOCALHOST6_BYTES);
    } catch (Exception e) {
      // We should not get here as long as the length of the address is correct.
      PlatformDependent.throwException(e);
    }
    LOCALHOST6 = localhost6;

    // Retrieve the list of available network interfaces.
    List<NetworkInterface> ifaces = new ArrayList<NetworkInterface>();
    try {
      Enumeration<NetworkInterface> interfaces = NetworkInterface.getNetworkInterfaces();
      if (interfaces != null) {
        while (interfaces.hasMoreElements()) {
          NetworkInterface iface = interfaces.nextElement();
          // Use the interface with proper INET addresses only.
          if (SocketUtils.addressesFromNetworkInterface(iface).hasMoreElements()) {
            ifaces.add(iface);
          }
        }
      }
    } catch (SocketException e) {
      logger.warn("Failed to retrieve the list of available network interfaces", e);
    }

    // Find the first loopback interface available from its INET address (127.0.0.1 or ::1)
    // Note that we do not use NetworkInterface.isLoopback() in the first place because it takes long time
    // on a certain environment. (e.g. Windows with -Djava.net.preferIPv4Stack=true)
    NetworkInterface loopbackIface = null;
    InetAddress loopbackAddr = null;
    loop:
    for (NetworkInterface iface : ifaces) {
      for (Enumeration<InetAddress> i = SocketUtils.addressesFromNetworkInterface(iface);
          i.hasMoreElements(); ) {
        InetAddress addr = i.nextElement();
        if (addr.isLoopbackAddress()) {
          // Found
          loopbackIface = iface;
          loopbackAddr = addr;
          break loop;
        }
      }
    }

    // If failed to find the loopback interface from its INET address, fall back to isLoopback().
    if (loopbackIface == null) {
      try {
        for (NetworkInterface iface : ifaces) {
          if (iface.isLoopback()) {
            Enumeration<InetAddress> i = SocketUtils.addressesFromNetworkInterface(iface);
            if (i.hasMoreElements()) {
              // Found the one with INET address.
              loopbackIface = iface;
              loopbackAddr = i.nextElement();
              break;
            }
          }
        }

        if (loopbackIface == null) {
          logger.warn("Failed to find the loopback interface");
        }
      } catch (SocketException e) {
        logger.warn("Failed to find the loopback interface", e);
      }
    }

    if (loopbackIface != null) {
      // Found the loopback interface with an INET address.
      logger.debug(
          "Loopback interface: {} ({}, {})",
          loopbackIface.getName(), loopbackIface.getDisplayName(), loopbackAddr.getHostAddress());
    } else {
      // Could not find the loopback interface, but we can't leave LOCALHOST as null.
      // Use LOCALHOST6 or LOCALHOST4, preferably the IPv6 one.
      if (loopbackAddr == null) {
        try {
          if (NetworkInterface.getByInetAddress(LOCALHOST6) != null) {
            logger.debug("Using hard-coded IPv6 localhost address: {}", localhost6);
            loopbackAddr = localhost6;
          }
        } catch (Exception e) {
          // Ignore
        } finally {
          if (loopbackAddr == null) {
            logger.debug("Using hard-coded IPv4 localhost address: {}", localhost4);
            loopbackAddr = localhost4;
          }
        }
      }
    }

    LOOPBACK_IF = loopbackIface;
    LOCALHOST = loopbackAddr;

    // As a SecurityManager may prevent reading the somaxconn file we wrap this in a privileged block.
    //
    // See https://github.com/netty/netty/issues/3680
    SOMAXCONN = AccessController.doPrivileged(new PrivilegedAction<Integer>() {
      @Override
      public Integer run() {
        // Determine the default somaxconn (server socket backlog) value of the platform.
        // The known defaults:
        // - Windows NT Server 4.0+: 200
        // - Linux and Mac OS X: 128
        int somaxconn = PlatformDependent.isWindows() ? 200 : 128;
        File file = new File("/proc/sys/net/core/somaxconn");
        BufferedReader in = null;
        try {
          // file.exists() may throw a SecurityException if a SecurityManager is used, so execute it in the
          // try / catch block.
          // See https://github.com/netty/netty/issues/4936
          if (file.exists()) {
            in = new BufferedReader(new FileReader(file));
            somaxconn = Integer.parseInt(in.readLine());
            if (logger.isDebugEnabled()) {
              logger.debug("{}: {}", file, somaxconn);
            }
          } else {
            // Try to get from sysctl
            Integer tmp = null;
            if (SystemPropertyUtil.getBoolean("io.netty.net.somaxconn.trySysctl", false)) {
              tmp = sysctlGetInt("kern.ipc.somaxconn");
              if (tmp == null) {
                tmp = sysctlGetInt("kern.ipc.soacceptqueue");
                if (tmp != null) {
                  somaxconn = tmp;
                }
              } else {
                somaxconn = tmp;
              }
            }

            if (tmp == null) {
              logger.debug("Failed to get SOMAXCONN from sysctl and file {}. Default: {}", file,
                  somaxconn);
            }
          }
        } catch (Exception e) {
          logger.debug("Failed to get SOMAXCONN from sysctl and file {}. Default: {}", file,
              somaxconn, e);
        } finally {
          if (in != null) {
            try {
              in.close();
            } catch (Exception e) {
              // Ignored.
            }
          }
        }
        return somaxconn;
      }
    });
  }

  /**
   * This will execute <a href ="https://www.freebsd.org/cgi/man.cgi?sysctl(8)">sysctl</a> with the
   * {@code sysctlKey} which is expected to return the numeric value for for {@code sysctlKey}.
   *
   * @param sysctlKey The key which the return value corresponds to.
   * @return The <a href ="https://www.freebsd.org/cgi/man.cgi?sysctl(8)">sysctl</a> value for
   * {@code sysctlKey}.
   */
  private static Integer sysctlGetInt(String sysctlKey) throws IOException {
    Process process = new ProcessBuilder("sysctl", sysctlKey).start();
    try {
      InputStream is = process.getInputStream();
      InputStreamReader isr = new InputStreamReader(is);
      BufferedReader br = new BufferedReader(isr);
      try {
        String line = br.readLine();
        if (line.startsWith(sysctlKey)) {
          for (int i = line.length() - 1; i > sysctlKey.length(); --i) {
            if (!Character.isDigit(line.charAt(i))) {
              return Integer.valueOf(line.substring(i + 1, line.length()));
            }
          }
        }
        return null;
      } finally {
        br.close();
      }
    } finally {
      if (process != null) {
        process.destroy();
      }
    }
  }

  /**
   * Returns {@code true} if IPv4 should be used even if the system supports both IPv4 and IPv6.
   * Setting this property to {@code true} will disable IPv6 support. The default value of this
   * property is {@code false}.
   *
   * @see <a href="https://docs.oracle.com/javase/8/docs/api/java/net/doc-files/net-properties.html">Java
   * SE networking properties</a>
   */
  public static boolean isIpV4StackPreferred() {
    return IPV4_PREFERRED;
  }

  /**
   * Returns {@code true} if an IPv6 address should be preferred when a host has both an IPv4
   * address and an IPv6 address. The default value of this property is {@code false}.
   *
   * @see <a href="https://docs.oracle.com/javase/8/docs/api/java/net/doc-files/net-properties.html">Java
   * SE networking properties</a>
   */
  public static boolean isIpV6AddressesPreferred() {
    return IPV6_ADDRESSES_PREFERRED;
  }

  /**
   * Creates an byte[] based on an ipAddressString. No error handling is performed here.
   */
  public static byte[] createByteArrayFromIpAddressString(String ipAddressString) {

    if (isValidIpV4Address(ipAddressString)) {
      return validIpV4ToBytes(ipAddressString);
    }

    if (isValidIpV6Address(ipAddressString)) {
      if (ipAddressString.charAt(0) == '[') {
        ipAddressString = ipAddressString.substring(1, ipAddressString.length() - 1);
      }

      int percentPos = ipAddressString.indexOf('%');
      if (percentPos >= 0) {
        ipAddressString = ipAddressString.substring(0, percentPos);
      }

      return getIPv6ByName(ipAddressString, true);
    }
    return null;
  }

  private static int decimalDigit(String str, int pos) {
    return str.charAt(pos) - '0';
  }

  private static byte ipv4WordToByte(String ip, int from, int toExclusive) {
    int ret = decimalDigit(ip, from);
    from++;
    if (from == toExclusive) {
      return (byte) ret;
    }
    ret = ret * 10 + decimalDigit(ip, from);
    from++;
    if (from == toExclusive) {
      return (byte) ret;
    }
    return (byte) (ret * 10 + decimalDigit(ip, from));
  }

  // visible for tests
  static byte[] validIpV4ToBytes(String ip) {
    int i;
    return new byte[]{
        ipv4WordToByte(ip, 0, i = ip.indexOf('.', 1)),
        ipv4WordToByte(ip, i + 1, i = ip.indexOf('.', i + 2)),
        ipv4WordToByte(ip, i + 1, i = ip.indexOf('.', i + 2)),
        ipv4WordToByte(ip, i + 1, ip.length())
    };
  }

  /**
   * Converts a 32-bit integer into an IPv4 address.
   */
  public static String intToIpAddress(int i) {
    StringBuilder buf = new StringBuilder(15);
    buf.append(i >> 24 & 0xff);
    buf.append('.');
    buf.append(i >> 16 & 0xff);
    buf.append('.');
    buf.append(i >> 8 & 0xff);
    buf.append('.');
    buf.append(i & 0xff);
    return buf.toString();
  }

  /**
   * Converts 4-byte or 16-byte data into an IPv4 or IPv6 string respectively.
   *
   * @throws IllegalArgumentException if {@code length} is not {@code 4} nor {@code 16}
   */
  public static String bytesToIpAddress(byte[] bytes) {
    return bytesToIpAddress(bytes, 0, bytes.length);
  }

  /**
   * Converts 4-byte or 16-byte data into an IPv4 or IPv6 string respectively.
   *
   * @throws IllegalArgumentException if {@code length} is not {@code 4} nor {@code 16}
   */
  public static String bytesToIpAddress(byte[] bytes, int offset, int length) {
    switch (length) {
      case 4: {
        return new StringBuilder(15)
            .append(bytes[offset] & 0xff)
            .append('.')
            .append(bytes[offset + 1] & 0xff)
            .append('.')
            .append(bytes[offset + 2] & 0xff)
            .append('.')
            .append(bytes[offset + 3] & 0xff).toString();
      }
      case 16:
        return toAddressString(bytes, offset, false);
      default:
        throw new IllegalArgumentException("length: " + length + " (expected: 4 or 16)");
    }
  }

  public static boolean isValidIpV6Address(String ip) {
    return isValidIpV6Address((CharSequence) ip);
  }

  public static boolean isValidIpV6Address(CharSequence ip) {
    int end = ip.length();
    if (end < 2) {
      return false;
    }

    // strip "[]"
    int start;
    char c = ip.charAt(0);
    if (c == '[') {
      end--;
      if (ip.charAt(end) != ']') {
        // must have a close ]
        return false;
      }
      start = 1;
      c = ip.charAt(1);
    } else {
      start = 0;
    }

    int colons;
    int compressBegin;
    if (c == ':') {
      // an IPv6 address can start with "::" or with a number
      if (ip.charAt(start + 1) != ':') {
        return false;
      }
      colons = 2;
      compressBegin = start;
      start += 2;
    } else {
      colons = 0;
      compressBegin = -1;
    }

    int wordLen = 0;
    loop:
    for (int i = start; i < end; i++) {
      c = ip.charAt(i);
      if (isValidHexChar(c)) {
        if (wordLen < 4) {
          wordLen++;
          continue;
        }
        return false;
      }

      switch (c) {
        case ':':
          if (colons > 7) {
            return false;
          }
          if (ip.charAt(i - 1) == ':') {
            if (compressBegin >= 0) {
              return false;
            }
            compressBegin = i - 1;
          } else {
            wordLen = 0;
          }
          colons++;
          break;
        case '.':
          // case for the last 32-bits represented as IPv4 x:x:x:x:x:x:d.d.d.d

          // check a normal case (6 single colons)
          if (compressBegin < 0 && colons != 6 ||
              // a special case ::1:2:3:4:5:d.d.d.d allows 7 colons with an
              // IPv4 ending, otherwise 7 :'s is bad
              (colons == 7 && compressBegin >= start || colons > 7)) {
            return false;
          }

          // Verify this address is of the correct structure to contain an IPv4 address.
          // It must be IPv4-Mapped or IPv4-Compatible
          // (see https://tools.ietf.org/html/rfc4291#section-2.5.5).
          int ipv4Start = i - wordLen;
          int j = ipv4Start - 2; // index of character before the previous ':'.
          if (isValidIPv4MappedChar(ip.charAt(j))) {
            if (!isValidIPv4MappedChar(ip.charAt(j - 1)) ||
                !isValidIPv4MappedChar(ip.charAt(j - 2)) ||
                !isValidIPv4MappedChar(ip.charAt(j - 3))) {
              return false;
            }
            j -= 5;
          }

          for (; j >= start; --j) {
            char tmpChar = ip.charAt(j);
            if (tmpChar != '0' && tmpChar != ':') {
              return false;
            }
          }

          // 7 - is minimum IPv4 address length
          int ipv4End = indexOf(ip, '%', ipv4Start + 7);
          if (ipv4End < 0) {
            ipv4End = end;
          }
          return isValidIpV4Address(ip, ipv4Start, ipv4End);
        case '%':
          // strip the interface name/index after the percent sign
          end = i;
          break loop;
        default:
          return false;
      }
    }

    // normal case without compression
    if (compressBegin < 0) {
      return colons == 7 && wordLen > 0;
    }

    return compressBegin + 2 == end ||
        // 8 colons is valid only if compression in start or end
        wordLen > 0 && (colons < 8 || compressBegin <= start);
  }

  private static boolean isValidIpV4Word(CharSequence word, int from, int toExclusive) {
    int len = toExclusive - from;
    char c0, c1, c2;
    if (len < 1 || len > 3 || (c0 = word.charAt(from)) < '0') {
      return false;
    }
    if (len == 3) {
      return (c1 = word.charAt(from + 1)) >= '0' &&
          (c2 = word.charAt(from + 2)) >= '0' &&
          (c0 <= '1' && c1 <= '9' && c2 <= '9' ||
              c0 == '2' && c1 <= '5' && (c2 <= '5' || c1 < '5' && c2 <= '9'));
    }
    return c0 <= '9' && (len == 1 || isValidNumericChar(word.charAt(from + 1)));
  }

  private static boolean isValidHexChar(char c) {
    return c >= '0' && c <= '9' || c >= 'A' && c <= 'F' || c >= 'a' && c <= 'f';
  }

  private static boolean isValidNumericChar(char c) {
    return c >= '0' && c <= '9';
  }

  private static boolean isValidIPv4MappedChar(char c) {
    return c == 'f' || c == 'F';
  }

  private static boolean isValidIPv4MappedSeparators(byte b0, byte b1, boolean mustBeZero) {
    // We allow IPv4 Mapped (https://tools.ietf.org/html/rfc4291#section-2.5.5.1)
    // and IPv4 compatible (https://tools.ietf.org/html/rfc4291#section-2.5.5.1).
    // The IPv4 compatible is deprecated, but it allows parsing of plain IPv4 addressed into IPv6-Mapped addresses.
    return b0 == b1 && (b0 == 0 || !mustBeZero && b1 == -1);
  }

  private static boolean isValidIPv4Mapped(byte[] bytes, int currentIndex, int compressBegin,
      int compressLength) {
    final boolean mustBeZero = compressBegin + compressLength >= 14;
    return currentIndex <= 12 && currentIndex >= 2 && (!mustBeZero || compressBegin < 12) &&
        isValidIPv4MappedSeparators(bytes[currentIndex - 1], bytes[currentIndex - 2], mustBeZero) &&
        PlatformDependent.isZero(bytes, 0, currentIndex - 3);
  }

  /**
   * Takes a {@link CharSequence} and parses it to see if it is a valid IPV4 address.
   *
   * @return true, if the string represents an IPV4 address in dotted notation, false otherwise
   */
  public static boolean isValidIpV4Address(CharSequence ip) {
    return isValidIpV4Address(ip, 0, ip.length());
  }

  /**
   * Takes a {@link String} and parses it to see if it is a valid IPV4 address.
   *
   * @return true, if the string represents an IPV4 address in dotted notation, false otherwise
   */
  public static boolean isValidIpV4Address(String ip) {
    return isValidIpV4Address(ip, 0, ip.length());
  }

  private static boolean isValidIpV4Address(CharSequence ip, int from, int toExcluded) {
    return ip instanceof String ? isValidIpV4Address((String) ip, from, toExcluded) :
        ip instanceof AsciiString ? isValidIpV4Address((AsciiString) ip, from, toExcluded) :
            isValidIpV4Address0(ip, from, toExcluded);
  }

  @SuppressWarnings("DuplicateBooleanBranch")
  private static boolean isValidIpV4Address(String ip, int from, int toExcluded) {
    int len = toExcluded - from;
    int i;
    return len <= 15 && len >= 7 &&
        (i = ip.indexOf('.', from + 1)) > 0 && isValidIpV4Word(ip, from, i) &&
        (i = ip.indexOf('.', from = i + 2)) > 0 && isValidIpV4Word(ip, from - 1, i) &&
        (i = ip.indexOf('.', from = i + 2)) > 0 && isValidIpV4Word(ip, from - 1, i) &&
        isValidIpV4Word(ip, i + 1, toExcluded);
  }

  @SuppressWarnings("DuplicateBooleanBranch")
  private static boolean isValidIpV4Address(AsciiString ip, int from, int toExcluded) {
    int len = toExcluded - from;
    int i;
    return len <= 15 && len >= 7 &&
        (i = ip.indexOf('.', from + 1)) > 0 && isValidIpV4Word(ip, from, i) &&
        (i = ip.indexOf('.', from = i + 2)) > 0 && isValidIpV4Word(ip, from - 1, i) &&
        (i = ip.indexOf('.', from = i + 2)) > 0 && isValidIpV4Word(ip, from - 1, i) &&
        isValidIpV4Word(ip, i + 1, toExcluded);
  }

  @SuppressWarnings("DuplicateBooleanBranch")
  private static boolean isValidIpV4Address0(CharSequence ip, int from, int toExcluded) {
    int len = toExcluded - from;
    int i;
    return len <= 15 && len >= 7 &&
        (i = indexOf(ip, '.', from + 1)) > 0 && isValidIpV4Word(ip, from, i) &&
        (i = indexOf(ip, '.', from = i + 2)) > 0 && isValidIpV4Word(ip, from - 1, i) &&
        (i = indexOf(ip, '.', from = i + 2)) > 0 && isValidIpV4Word(ip, from - 1, i) &&
        isValidIpV4Word(ip, i + 1, toExcluded);
  }

  /**
   * Returns the {@link Inet6Address} representation of a {@link CharSequence} IP address.
   * <p>
   * This method will treat all IPv4 type addresses as "IPv4 mapped" (see {@link
   * #getByName(CharSequence, boolean)})
   *
   * @param ip {@link CharSequence} IP address to be converted to a {@link Inet6Address}
   * @return {@link Inet6Address} representation of the {@code ip} or {@code null} if not a valid IP
   * address.
   */
  public static Inet6Address getByName(CharSequence ip) {
    return getByName(ip, true);
  }

  /**
   * Returns the {@link Inet6Address} representation of a {@link CharSequence} IP address.
   * <p>
   * The {@code ipv4Mapped} parameter specifies how IPv4 addresses should be treated. "IPv4 mapped"
   * format as defined in <a href="http://tools.ietf.org/html/rfc4291#section-2.5.5">rfc 4291
   * section 2</a> is supported.
   *
   * @param ip {@link CharSequence} IP address to be converted to a {@link Inet6Address}
   * @param ipv4Mapped <ul>
   * <li>{@code true} To allow IPv4 mapped inputs to be translated into {@link Inet6Address}</li>
   * <li>{@code false} Consider IPv4 mapped addresses as invalid.</li>
   * </ul>
   * @return {@link Inet6Address} representation of the {@code ip} or {@code null} if not a valid IP
   * address.
   */
  public static Inet6Address getByName(CharSequence ip, boolean ipv4Mapped) {
    byte[] bytes = getIPv6ByName(ip, ipv4Mapped);
    if (bytes == null) {
      return null;
    }
    try {
      return Inet6Address.getByAddress(null, bytes, -1);
    } catch (UnknownHostException e) {
      throw new RuntimeException(e); // Should never happen
    }
  }

  /**
   * Returns the byte array representation of a {@link CharSequence} IP address.
   * <p>
   * The {@code ipv4Mapped} parameter specifies how IPv4 addresses should be treated. "IPv4 mapped"
   * format as defined in <a href="http://tools.ietf.org/html/rfc4291#section-2.5.5">rfc 4291
   * section 2</a> is supported.
   *
   * @param ip {@link CharSequence} IP address to be converted to a {@link Inet6Address}
   * @param ipv4Mapped <ul>
   * <li>{@code true} To allow IPv4 mapped inputs to be translated into {@link Inet6Address}</li>
   * <li>{@code false} Consider IPv4 mapped addresses as invalid.</li>
   * </ul>
   * @return byte array representation of the {@code ip} or {@code null} if not a valid IP address.
   */
  private static byte[] getIPv6ByName(CharSequence ip, boolean ipv4Mapped) {
    final byte[] bytes = new byte[IPV6_BYTE_COUNT];
    final int ipLength = ip.length();
    int compressBegin = 0;
    int compressLength = 0;
    int currentIndex = 0;
    int value = 0;
    int begin = -1;
    int i = 0;
    int ipv6Separators = 0;
    int ipv4Separators = 0;
    int tmp;
    boolean needsShift = false;
    for (; i < ipLength; ++i) {
      final char c = ip.charAt(i);
      switch (c) {
        case ':':
          ++ipv6Separators;
          if (i - begin > IPV6_MAX_CHAR_BETWEEN_SEPARATOR ||
              ipv4Separators > 0 || ipv6Separators > IPV6_MAX_SEPARATORS ||
              currentIndex + 1 >= bytes.length) {
            return null;
          }
          value <<= (IPV6_MAX_CHAR_BETWEEN_SEPARATOR - (i - begin)) << 2;

          if (compressLength > 0) {
            compressLength -= 2;
          }

          // The value integer holds at most 4 bytes from right (most significant) to left (least significant).
          // The following bit shifting is used to extract and re-order the individual bytes to achieve a
          // left (most significant) to right (least significant) ordering.
          bytes[currentIndex++] = (byte) (((value & 0xf) << 4) | ((value >> 4) & 0xf));
          bytes[currentIndex++] = (byte) ((((value >> 8) & 0xf) << 4) | ((value >> 12) & 0xf));
          tmp = i + 1;
          if (tmp < ipLength && ip.charAt(tmp) == ':') {
            ++tmp;
            if (compressBegin != 0 || (tmp < ipLength && ip.charAt(tmp) == ':')) {
              return null;
            }
            ++ipv6Separators;
            needsShift = ipv6Separators == 2 && value == 0;
            compressBegin = currentIndex;
            compressLength = bytes.length - compressBegin - 2;
            ++i;
          }
          value = 0;
          begin = -1;
          break;
        case '.':
          ++ipv4Separators;
          tmp = i - begin; // tmp is the length of the current segment.
          if (tmp > IPV4_MAX_CHAR_BETWEEN_SEPARATOR
              || begin < 0
              || ipv4Separators > IPV4_SEPARATORS
              || (ipv6Separators > 0 && (currentIndex + compressLength < 12))
              || i + 1 >= ipLength
              || currentIndex >= bytes.length
              || ipv4Separators == 1 &&
              // We also parse pure IPv4 addresses as IPv4-Mapped for ease of use.
              ((!ipv4Mapped || currentIndex != 0 && !isValidIPv4Mapped(bytes, currentIndex,
                  compressBegin, compressLength)) ||
                  (tmp == 3 && (!isValidNumericChar(ip.charAt(i - 1)) ||
                      !isValidNumericChar(ip.charAt(i - 2)) ||
                      !isValidNumericChar(ip.charAt(i - 3))) ||
                      tmp == 2 && (!isValidNumericChar(ip.charAt(i - 1)) ||
                          !isValidNumericChar(ip.charAt(i - 2))) ||
                      tmp == 1 && !isValidNumericChar(ip.charAt(i - 1))))) {
            return null;
          }
          value <<= (IPV4_MAX_CHAR_BETWEEN_SEPARATOR - tmp) << 2;

          // The value integer holds at most 3 bytes from right (most significant) to left (least significant).
          // The following bit shifting is to restructure the bytes to be left (most significant) to
          // right (least significant) while also accounting for each IPv4 digit is base 10.
          begin = (value & 0xf) * 100 + ((value >> 4) & 0xf) * 10 + ((value >> 8) & 0xf);
          if (begin < 0 || begin > 255) {
            return null;
          }
          bytes[currentIndex++] = (byte) begin;
          value = 0;
          begin = -1;
          break;
        default:
          if (!isValidHexChar(c) || (ipv4Separators > 0 && !isValidNumericChar(c))) {
            return null;
          }
          if (begin < 0) {
            begin = i;
          } else if (i - begin > IPV6_MAX_CHAR_BETWEEN_SEPARATOR) {
            return null;
          }
          // The value is treated as a sort of array of numbers because we are dealing with
          // at most 4 consecutive bytes we can use bit shifting to accomplish this.
          // The most significant byte will be encountered first, and reside in the right most
          // position of the following integer
          value += StringUtil.decodeHexNibble(c) << ((i - begin) << 2);
          break;
      }
    }

    final boolean isCompressed = compressBegin > 0;
    // Finish up last set of data that was accumulated in the loop (or before the loop)
    if (ipv4Separators > 0) {
      if (begin > 0 && i - begin > IPV4_MAX_CHAR_BETWEEN_SEPARATOR ||
          ipv4Separators != IPV4_SEPARATORS ||
          currentIndex >= bytes.length) {
        return null;
      }
      if (ipv6Separators == 0) {
        compressLength = 12;
      } else if (ipv6Separators >= IPV6_MIN_SEPARATORS &&
          (!isCompressed && (ipv6Separators == 6 && ip.charAt(0) != ':') ||
              isCompressed && (ipv6Separators < IPV6_MAX_SEPARATORS &&
                  (ip.charAt(0) != ':' || compressBegin <= 2)))) {
        compressLength -= 2;
      } else {
        return null;
      }
      value <<= (IPV4_MAX_CHAR_BETWEEN_SEPARATOR - (i - begin)) << 2;

      // The value integer holds at most 3 bytes from right (most significant) to left (least significant).
      // The following bit shifting is to restructure the bytes to be left (most significant) to
      // right (least significant) while also accounting for each IPv4 digit is base 10.
      begin = (value & 0xf) * 100 + ((value >> 4) & 0xf) * 10 + ((value >> 8) & 0xf);
      if (begin < 0 || begin > 255) {
        return null;
      }
      bytes[currentIndex++] = (byte) begin;
    } else {
      tmp = ipLength - 1;
      if (begin > 0 && i - begin > IPV6_MAX_CHAR_BETWEEN_SEPARATOR ||
          ipv6Separators < IPV6_MIN_SEPARATORS ||
          !isCompressed && (ipv6Separators + 1 != IPV6_MAX_SEPARATORS ||
              ip.charAt(0) == ':' || ip.charAt(tmp) == ':') ||
          isCompressed && (ipv6Separators > IPV6_MAX_SEPARATORS ||
              (ipv6Separators == IPV6_MAX_SEPARATORS &&
                  (compressBegin <= 2 && ip.charAt(0) != ':' ||
                      compressBegin >= 14 && ip.charAt(tmp) != ':'))) ||
          currentIndex + 1 >= bytes.length ||
          begin < 0 && ip.charAt(tmp - 1) != ':' ||
          compressBegin > 2 && ip.charAt(0) == ':') {
        return null;
      }
      if (begin >= 0 && i - begin <= IPV6_MAX_CHAR_BETWEEN_SEPARATOR) {
        value <<= (IPV6_MAX_CHAR_BETWEEN_SEPARATOR - (i - begin)) << 2;
      }
      // The value integer holds at most 4 bytes from right (most significant) to left (least significant).
      // The following bit shifting is used to extract and re-order the individual bytes to achieve a
      // left (most significant) to right (least significant) ordering.
      bytes[currentIndex++] = (byte) (((value & 0xf) << 4) | ((value >> 4) & 0xf));
      bytes[currentIndex++] = (byte) ((((value >> 8) & 0xf) << 4) | ((value >> 12) & 0xf));
    }

    i = currentIndex + compressLength;
    if (needsShift || i >= bytes.length) {
      // Right shift array
      if (i >= bytes.length) {
        ++compressBegin;
      }
      for (i = currentIndex; i < bytes.length; ++i) {
        for (begin = bytes.length - 1; begin >= compressBegin; --begin) {
          bytes[begin] = bytes[begin - 1];
        }
        bytes[begin] = 0;
        ++compressBegin;
      }
    } else {
      // Selectively move elements
      for (i = 0; i < compressLength; ++i) {
        begin = i + compressBegin;
        currentIndex = begin + compressLength;
        if (currentIndex < bytes.length) {
          bytes[currentIndex] = bytes[begin];
          bytes[begin] = 0;
        } else {
          break;
        }
      }
    }

    if (ipv4Separators > 0) {
      // We only support IPv4-Mapped addresses [1] because IPv4-Compatible addresses are deprecated [2].
      // [1] https://tools.ietf.org/html/rfc4291#section-2.5.5.2
      // [2] https://tools.ietf.org/html/rfc4291#section-2.5.5.1
      bytes[10] = bytes[11] = (byte) 0xff;
    }

    return bytes;
  }

  /**
   * Returns the {@link String} representation of an {@link InetSocketAddress}.
   * <p>
   * The output does not include Scope ID.
   *
   * @param addr {@link InetSocketAddress} to be converted to an address string
   * @return {@code String} containing the text-formatted IP address
   */
  public static String toSocketAddressString(InetSocketAddress addr) {
    String port = String.valueOf(addr.getPort());
    final StringBuilder sb;

    if (addr.isUnresolved()) {
      String hostname = getHostname(addr);
      sb = newSocketAddressStringBuilder(hostname, port, !isValidIpV6Address(hostname));
    } else {
      InetAddress address = addr.getAddress();
      String hostString = toAddressString(address);
      sb = newSocketAddressStringBuilder(hostString, port, address instanceof Inet4Address);
    }
    return sb.append(':').append(port).toString();
  }

  /**
   * Returns the {@link String} representation of a host port combo.
   */
  public static String toSocketAddressString(String host, int port) {
    String portStr = String.valueOf(port);
    return newSocketAddressStringBuilder(
        host, portStr, !isValidIpV6Address(host)).append(':').append(portStr).toString();
  }

  private static StringBuilder newSocketAddressStringBuilder(String host, String port,
      boolean ipv4) {
    int hostLen = host.length();
    if (ipv4) {
      // Need to include enough space for hostString:port.
      return new StringBuilder(hostLen + 1 + port.length()).append(host);
    }
    // Need to include enough space for [hostString]:port.
    StringBuilder stringBuilder = new StringBuilder(hostLen + 3 + port.length());
    if (hostLen > 1 && host.charAt(0) == '[' && host.charAt(hostLen - 1) == ']') {
      return stringBuilder.append(host);
    }
    return stringBuilder.append('[').append(host).append(']');
  }

  /**
   * Returns the {@link String} representation of an {@link InetAddress}.
   * <ul>
   * <li>Inet4Address results are identical to {@link InetAddress#getHostAddress()}</li>
   * <li>Inet6Address results adhere to
   * <a href="http://tools.ietf.org/html/rfc5952#section-4">rfc 5952 section 4</a></li>
   * </ul>
   * <p>
   * The output does not include Scope ID.
   *
   * @param ip {@link InetAddress} to be converted to an address string
   * @return {@code String} containing the text-formatted IP address
   */
  public static String toAddressString(InetAddress ip) {
    return toAddressString(ip, false);
  }

  /**
   * Returns the {@link String} representation of an {@link InetAddress}.
   * <ul>
   * <li>Inet4Address results are identical to {@link InetAddress#getHostAddress()}</li>
   * <li>Inet6Address results adhere to
   * <a href="http://tools.ietf.org/html/rfc5952#section-4">rfc 5952 section 4</a> if
   * {@code ipv4Mapped} is false.  If {@code ipv4Mapped} is true then "IPv4 mapped" format from <a
   * href="http://tools.ietf.org/html/rfc4291#section-2.5.5">rfc 4291 section 2</a> will be
   * supported. The compressed result will always obey the compression rules defined in
   * <a href="http://tools.ietf.org/html/rfc5952#section-4">rfc 5952 section 4</a></li>
   * </ul>
   * <p>
   * The output does not include Scope ID.
   *
   * @param ip {@link InetAddress} to be converted to an address string
   * @param ipv4Mapped <ul>
   * <li>{@code true} to stray from strict rfc 5952 and support the "IPv4 mapped" format
   * defined in <a href="http://tools.ietf.org/html/rfc4291#section-2.5.5">rfc 4291 section 2</a>
   * while still following the updated guidelines in
   * <a href="http://tools.ietf.org/html/rfc5952#section-4">rfc 5952 section 4</a></li>
   * <li>{@code false} to strictly follow rfc 5952</li>
   * </ul>
   * @return {@code String} containing the text-formatted IP address
   */
  public static String toAddressString(InetAddress ip, boolean ipv4Mapped) {
    if (ip instanceof Inet4Address) {
      return ip.getHostAddress();
    }
    if (!(ip instanceof Inet6Address)) {
      throw new IllegalArgumentException("Unhandled type: " + ip);
    }

    return toAddressString(ip.getAddress(), 0, ipv4Mapped);
  }

  private static String toAddressString(byte[] bytes, int offset, boolean ipv4Mapped) {
    final int[] words = new int[IPV6_WORD_COUNT];
    int i;
    final int end = offset + words.length;
    for (i = offset; i < end; ++i) {
      words[i] = ((bytes[i << 1] & 0xff) << 8) | (bytes[(i << 1) + 1] & 0xff);
    }

    // Find longest run of 0s, tie goes to first found instance
    int currentStart = -1;
    int currentLength;
    int shortestStart = -1;
    int shortestLength = 0;
    for (i = 0; i < words.length; ++i) {
      if (words[i] == 0) {
        if (currentStart < 0) {
          currentStart = i;
        }
      } else if (currentStart >= 0) {
        currentLength = i - currentStart;
        if (currentLength > shortestLength) {
          shortestStart = currentStart;
          shortestLength = currentLength;
        }
        currentStart = -1;
      }
    }
    // If the array ends on a streak of zeros, make sure we account for it
    if (currentStart >= 0) {
      currentLength = i - currentStart;
      if (currentLength > shortestLength) {
        shortestStart = currentStart;
        shortestLength = currentLength;
      }
    }
    // Ignore the longest streak if it is only 1 long
    if (shortestLength == 1) {
      shortestLength = 0;
      shortestStart = -1;
    }

    // Translate to string taking into account longest consecutive 0s
    final int shortestEnd = shortestStart + shortestLength;
    final StringBuilder b = new StringBuilder(IPV6_MAX_CHAR_COUNT);
    if (shortestEnd < 0) { // Optimization when there is no compressing needed
      b.append(Integer.toHexString(words[0]));
      for (i = 1; i < words.length; ++i) {
        b.append(':');
        b.append(Integer.toHexString(words[i]));
      }
    } else { // General case that can handle compressing (and not compressing)
      // Loop unroll the first index (so we don't constantly check i==0 cases in loop)
      final boolean isIpv4Mapped;
      if (inRangeEndExclusive(0, shortestStart, shortestEnd)) {
        b.append("::");
        isIpv4Mapped = ipv4Mapped && (shortestEnd == 5 && words[5] == 0xffff);
      } else {
        b.append(Integer.toHexString(words[0]));
        isIpv4Mapped = false;
      }
      for (i = 1; i < words.length; ++i) {
        if (!inRangeEndExclusive(i, shortestStart, shortestEnd)) {
          if (!inRangeEndExclusive(i - 1, shortestStart, shortestEnd)) {
            // If the last index was not part of the shortened sequence
            if (!isIpv4Mapped || i == 6) {
              b.append(':');
            } else {
              b.append('.');
            }
          }
          if (isIpv4Mapped && i > 5) {
            b.append(words[i] >> 8);
            b.append('.');
            b.append(words[i] & 0xff);
          } else {
            b.append(Integer.toHexString(words[i]));
          }
        } else if (!inRangeEndExclusive(i - 1, shortestStart, shortestEnd)) {
          // If we are in the shortened sequence and the last index was not
          b.append("::");
        }
      }
    }

    return b.toString();
  }

  /**
   * Returns {@link InetSocketAddress#getHostString()} if Java >= 7, or {@link
   * InetSocketAddress#getHostName()} otherwise.
   *
   * @param addr The address
   * @return the host string
   */
  public static String getHostname(InetSocketAddress addr) {
    return PlatformDependent.javaVersion() >= 7 ? addr.getHostString() : addr.getHostName();
  }

  /**
   * Does a range check on {@code value} if is within {@code start} (inclusive) and {@code end}
   * (exclusive).
   *
   * @param value The value to checked if is within {@code start} (inclusive) and {@code end}
   * (exclusive)
   * @param start The start of the range (inclusive)
   * @param end The end of the range (exclusive)
   * @return <ul>
   * <li>{@code true} if {@code value} if is within {@code start} (inclusive) and {@code end}
   * (exclusive)</li>
   * <li>{@code false} otherwise</li>
   * </ul>
   */
  private static boolean inRangeEndExclusive(int value, int start, int end) {
    return value >= start && value < end;
  }

  /**
   * A constructor to stop this class being constructed.
   */
  private NetUtil() {
    // Unused
  }
}
